package org.artifact.core.util;

import cn.hutool.core.lang.Console;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;

import java.util.ArrayList;
import java.util.HashMap;

public class ParseUtil {

    public static void main(String[] args) {
        HashMap<Integer,HashMap<Integer, Integer>> field11 = new HashMap<>();
        String s = "1=1=2,2=3,2=1=2,2=3";
        field11 = ParseHashMap("Integer,HashMap<Integer, Integer>",s);
        Console.log(field11);
    }

    public static int ParseInt(String s) {
        if (StrUtil.isEmpty(s)){
            return 0;
        }
        return Integer.valueOf(s);
    }

    public static int[] ParseIntArray(String s) {
        if (StrUtil.isEmpty(s)){
            return new int[0];
        }
        String[] strs = StrUtil.split(s, "#");
        int[] ints = new int[strs.length];
        for (int i = 0; i < ints.length; i++) {
            ints[i] = ParseInt(strs[i]);
        }
        return ints;
    }

    public static int[][] ParseIntsArray(String s) {
        if (StrUtil.isEmpty(s)){
            return new int[0][0];
        }
        String[] strs = StrUtil.split(s, "|");
        int[][] ints = new int[strs.length][];
        for (int i = 0; i < strs.length; i++) {
            ints[i] = ParseIntArray(strs[i]);
        }
        return ints;
    }

    public static String ParseStr(String s) {
        if (StrUtil.isEmpty(s)){
            return "";
        }
        return s;
    }

    public static String[] ParseStrArray(String s) {
        if (StrUtil.isEmpty(s)){
            return new String[0];
        }
        String[] strs = StrUtil.split(s, "#");
        return strs;
    }

    public static String[][] ParseStrsArray(String s) {
        if (StrUtil.isEmpty(s)){
            return new String[0][0];
        }
        String[] strs = StrUtil.split(s, "|");
        String[][] strss = new String[strs.length][];
        for (int i = 0; i < strs.length; i++) {
            strss[i] = ParseStrArray(strs[i]);
        }
        return strss;
    }

    public static HashMap ParseHashMap(String generic, String s) {
        HashMap map = new HashMap();
        if (StrUtil.isEmpty(s)){
            return map;
        }
        String[] strs = StrUtil.split(s, ",");
        for (int i = 0; i < strs.length; i++) {
            String[] kv = StrUtil.split(strs[i], "=");
            String[] generics = StrUtil.split(generic, ",");
            map.put(ParseObject(generics[0], kv[0]), ParseObject(generics[1], kv[1]));
        }
        return map;
    }

    public static ArrayList ParseList(String generic, String s) {
        ArrayList list = new ArrayList();
        if (StrUtil.isEmpty(s)){
            return list;
        }
        String[] strs = StrUtil.split(s, "|");
        for (int i = 0; i < strs.length; i++) {
            list.add(ParseObject(generic, strs[i]));
        }
        return list;
    }

    public static JSONObject ParseJson(String s) {
        if (StrUtil.isEmpty(s)){
            return new JSONObject();
        }
        return JSONUtil.parseObj(s);
    }

    public static Object ParseObject(String type, String str) {
        String _type = StrUtil.subBefore(type, "<", false).trim();

        // 取得泛型
        int index = type.indexOf("<");
        int fromIndex = type.indexOf("<");
        int toIndex = type.lastIndexOf(">");
        String generic = StrUtil.sub(type, fromIndex!=-1?fromIndex+1:-1, toIndex);

        if (_type.equals("HashMap")) {
            return ParseHashMap(generic, str);
        } else if (_type.equals("ArrayList")) {
            return ParseList(generic, str);
        } else if (_type.equals("Integer")) {
            return ParseInt(str);
        } else if (_type.equals("int[]")) {
            return ParseIntArray(str);
        } else if (_type.equals("int[][]")) {
            return ParseIntsArray(str);
        } else if (_type.equals("String")) {
            return ParseStr(str);
        } else if (_type.equals("String[]")) {
            return ParseStrArray(str);
        } else if (_type.equals("String[][]")) {
            return ParseStrsArray(str);
        }
        return null;
    }
}